package extraction;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

/**
 * Classe qui va contenir des méthodes permettant de trier nos hashmap.
 * @author ejouini
 *
 */
public class Tri {

	
	/**
	 * Méthode static qui trie une hashmap reçue en parametre et retourne les
	 * N mots avec la plus grande valeur en clé. Cette fonction prend des Value double.
	 * @param motsOcc
	 * @param N
	 * @return
	 */
	public static ArrayList<String> getNMotsPlusSignificatif(HashMap<String, Double> motsOcc, int N) {

		int i = 0;
		HashMap<String, Double> mapTriee = (HashMap<String, Double>) sortByValueDouble(motsOcc);
		ArrayList<String> mots = new ArrayList<String>();


		for (String key : mapTriee.keySet()) {
			if (i < N)
				mots.add(key);
			else 
				return mots;
			i++;
		}

		return mots;
	}
	
	
	/**
	 * Méthode static qui tri une hashmap reçue en parametre et retourne les
	 * N mots la plus grande valeur en clé. Cette fonction prend des Value entières.
	 * @param motsOcc
	 * @param N
	 * @return
	 */
	public static ArrayList<String> getNMotsPlusFrequents(HashMap<String, Integer> motsOcc, int N) {

		int i = 0;
		HashMap<String, Integer> mapTriee = (HashMap<String, Integer>) sortByValue(motsOcc);
		ArrayList<String> mots = new ArrayList<String>();


		for (String key : mapTriee.keySet()) {
			if (i < N)
				mots.add(key);
			else 
				return mots;
			i++;
		}
		//System.out.println(sortByValue(motsOcc));

		return mots;
	}

	/**
	 * Méthode qui retourne les N mots avec la plus petite valeur en value.
	 * Value doivent être double
	 * @param motsOcc
	 * @param N
	 * @return
	 */
	public static ArrayList<String> getNMotsMoinsSignificatif(HashMap<String, Double> motsOcc, int N) {

		int i = 0;
		HashMap<String, Double> mapTriee = (HashMap<String, Double>) sortByValueDouble(motsOcc);
		ArrayList<String> mots = new ArrayList<String>();


		for (String key : mapTriee.keySet()) {
			if (mapTriee.size()-i <= 20)
				mots.add(key);
			i++;
		}


		return mots;
	}
	
	/**
	 * Méthode qui retourne les N mots avec la plus petite valeur en value.
	 * Value doivent être entière
	 * @param motsOcc
	 * @param N
	 * @return
	 */
	public static ArrayList<String> getNMotsMoinsFrequents(HashMap<String, Integer> motsOcc, int N) {

		int i = 0;
		HashMap<String, Integer> mapTriee = (HashMap<String, Integer>) sortByValue(motsOcc);
		ArrayList<String> mots = new ArrayList<String>();


		for (String key : mapTriee.keySet()) {
			if (mapTriee.size()-i <= 20)
				mots.add(key);
			i++;
		}


		return mots;
	}

	
	public static Map<String, Double> sortByValueDouble(Map<String, Double> map) {
		List<Map.Entry<String, Double>> list = new LinkedList<Map.Entry<String, Double>>(map.entrySet());

		Collections.sort(list, new Comparator<Map.Entry<String, Double>>() {

			public int compare(Map.Entry<String, Double> m1, Map.Entry<String, Double> m2) {
				return (m2.getValue()).compareTo(m1.getValue());
			}
		});

		Map<String, Double> result = new LinkedHashMap<String, Double>();
		for (Map.Entry<String, Double> entry : list) {
			result.put(entry.getKey(), entry.getValue());
		}
		return result;
	}
	
	
	public static Map<String, Integer> sortByValue(Map<String, Integer> map) {
		List<Map.Entry<String, Integer>> list = new LinkedList<Map.Entry<String, Integer>>(map.entrySet());

		Collections.sort(list, new Comparator<Map.Entry<String, Integer>>() {

			public int compare(Map.Entry<String, Integer> m1, Map.Entry<String, Integer> m2) {
				return (m2.getValue()).compareTo(m1.getValue());
			}
		});

		Map<String, Integer> result = new LinkedHashMap<String, Integer>();
		for (Map.Entry<String, Integer> entry : list) {
			result.put(entry.getKey(), entry.getValue());
		}
		return result;
	}
	
	
}
